package com.example.tpl.system.service.impl;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.tpl.system.dao.DictDataDao;
import com.example.tpl.system.dao.DictTypeDao;
import com.example.tpl.system.entity.DictDataBean;
import com.example.tpl.system.entity.DictTypeBean;
import com.example.tpl.system.service.DictTypeService;
import com.example.tpl.system.util.Result;
import com.example.tpl.system.util.ResultPage;
import com.example.tpl.system.vo.common.DeleteBatchReqVo;
import com.example.tpl.system.vo.common.QueryDetailReqVo;
import com.example.tpl.system.vo.common.UpdateStatusReq;
import com.example.tpl.system.vo.req.DictTypeReqVo;
import com.example.tpl.system.vo.req.QueryDictTypeReqVo;
import com.example.tpl.system.vo.resp.DictTypeRespVo;

/**
 * 描述：字典类型
 * 作者：刘飞华
 * 日期：2025/01/10 15:34:35
 */
@Service
public class DictTypeServiceImpl implements DictTypeService {

    @Autowired
    private DictTypeDao dictTypeDao;

    @Autowired
    private DictDataDao dictDataDao;

    /**
     * 添加字典类型
     *
     * @param dict 请求参数
     * @return int
     * @author 刘飞华
     * @date: 2025/01/10 15:34:35
     */
    @Override
    public Result<Integer> addDictType(DictTypeReqVo dict) {
        String dictName = dict.getDictName();//字典名称
        String dictType = dict.getDictType();//字典类型

        if (dictTypeDao.selectCount(Wrappers.<DictTypeBean>lambdaQuery().eq(DictTypeBean::getDictName, dictName)) > 0) {
            return Result.error("字典名称已存在");
        }


        if (dictTypeDao.selectCount(Wrappers.<DictTypeBean>lambdaQuery().eq(DictTypeBean::getDictType, dictType)) > 0) {
            return Result.error("字典类型已存在");
        }

        DictTypeBean bean = new DictTypeBean();
        bean.setDictName(dictName); //字典名称
        bean.setDictType(dictType); //字典类型
        bean.setStatus(dict.getStatus()); //状态（0：停用，1:正常）
        bean.setRemark(dict.getRemark()); //备注
        int i = dictTypeDao.insert(bean);

        return Result.success(i);
    }

    /**
     * 删除字典类型
     *
     * @param dictType 请求参数
     * @return int
     * @author 刘飞华
     * @date: 2025/01/10 15:34:35
     */
    @Override
    public Result<Integer> deleteDictType(DeleteBatchReqVo dictType) {
        List<Long> ids = dictType.getIds();
        for (Long id : ids) {
            DictTypeBean dictTypeBean = dictTypeDao.selectById(id);
            if (dictTypeBean == null) {
                return Result.error("字典类型不存在");
            }

            if (dictDataDao.selectCount(Wrappers.<DictDataBean>lambdaQuery()
                                                .eq(DictDataBean::getDictType, dictTypeBean.getDictType())) > 0) {
                return Result.error("已分配,不能删除");
            }
        }

        int i = dictTypeDao.deleteByIds(ids);
        return Result.success(i);
    }

    /**
     * 更新字典类型
     *
     * @param dict 请求参数
     * @return int
     * @author 刘飞华
     * @date: 2025/01/10 15:34:35
     */
    @Override
    public Result<Integer> updateDictType(DictTypeReqVo dict) {
        String dictName = dict.getDictName();//字典名称
        String dictType = dict.getDictType();//字典类型

        if (dictTypeDao.selectCount(Wrappers.<DictTypeBean>lambdaQuery().eq(DictTypeBean::getId, dict.getId())) > 0) {
            return Result.error("字典类型不存在");
        }
        if (dictTypeDao.selectCount(Wrappers.<DictTypeBean>lambdaQuery()
                                            .eq(DictTypeBean::getDictName, dict.getDictName())
                                            .ne(DictTypeBean::getId, dict.getId())) > 0) {
            return Result.error("字典名称已存在");
        }

        if (dictTypeDao.selectCount(Wrappers.<DictTypeBean>lambdaQuery()
                                            .eq(DictTypeBean::getDictType, dict.getDictType())
                                            .ne(DictTypeBean::getId, dict.getId())) > 0) {
            return Result.error("字典类型已存在");
        }

        DictTypeBean bean = new DictTypeBean();
        bean.setId(dict.getId());//字典主键
        bean.setDictName(dictName);//字典名称
        bean.setDictType(dictType);//字典类型
        bean.setStatus(dict.getStatus());//状态（0：停用，1:正常）
        bean.setRemark(dict.getRemark());//备注

        int i = dictTypeDao.updateById(bean);
        return Result.success(i);
    }

    /**
     * 更新字典类型状态
     *
     * @param dictType 请求参数
     * @return int
     * @author 刘飞华
     * @date: 2025/01/10 15:34:35
     */
    @Override
    public Result<Integer> updateDictTypeStatus(UpdateStatusReq dictType) {

        int i = dictTypeDao.update(Wrappers.<DictTypeBean>lambdaUpdate()
                                           .in(DictTypeBean::getId, dictType.getIds())
                                           .set(DictTypeBean::getStatus, dictType.getStatus()));
        return Result.success(i);
    }

    /**
     * 查询字典类型详情
     *
     * @param dictType 请求参数
     * @return DictTypeResp
     * @author 刘飞华
     * @date: 2025/01/10 15:34:35
     */
    @Override
    public Result<DictTypeRespVo> queryDictTypeDetail(QueryDetailReqVo dictType) {


        DictTypeBean query = dictTypeDao.selectById(dictType.getId());
        if (query == null) {
            return Result.error("字典类型不存在");
        }

        DictTypeRespVo resp = new DictTypeRespVo();
        resp.setDictId(query.getId());//字典主键
        resp.setDictName(query.getDictName());//字典名称
        resp.setDictType(query.getDictType());//字典类型
        resp.setStatus(query.getStatus());//状态（0：停用，1:正常）
        resp.setRemark(query.getRemark());//备注
        resp.setCreateTime(query.getCreateTime());//创建时间
        resp.setUpdateTime(query.getUpdateTime());//修改时间

        return Result.success(resp);
    }

    /**
     * 查询字典类型列表
     *
     * @param dictType 请求参数
     * @return DictTypeResp
     * @author 刘飞华
     * @date: 2025/01/10 15:34:35
     */
    @Override
    public Result<ResultPage<DictTypeRespVo>> queryDictTypeList(QueryDictTypeReqVo dictType) {
        LambdaQueryWrapper<DictTypeBean> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.like(dictType.getDictName() != null, DictTypeBean::getDictName, dictType.getDictName());
        queryWrapper.like(dictType.getDictType() != null, DictTypeBean::getDictType, dictType.getDictType());
        queryWrapper.eq(dictType.getStatus() != null, DictTypeBean::getStatus, dictType.getStatus());

        Page<DictTypeBean> page = dictTypeDao.selectPage(new Page<>(dictType.getPageNo(), dictType.getPageSize()), queryWrapper);
        List<DictTypeRespVo> list = new ArrayList<>();

        for (DictTypeBean typeBean : page.getRecords()) {
            DictTypeRespVo resp = new DictTypeRespVo();
            resp.setDictId(typeBean.getId());//字典主键
            resp.setDictName(typeBean.getDictName());//字典名称
            resp.setDictType(typeBean.getDictType());//字典类型
            resp.setStatus(typeBean.getStatus());//状态（0：停用，1:正常）
            resp.setRemark(typeBean.getRemark());//备注
            resp.setCreateTime(typeBean.getCreateTime());//创建时间
            resp.setUpdateTime(typeBean.getUpdateTime());//修改时间

            list.add(resp);
        }

        return Result.success(new ResultPage<>(list, page.getCurrent(), page.getSize(), page.getTotal()));

    }
}